home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 008a / perl40_2.zip / DUMP.C < prev    next >
C/C++ Source or Header  |  1991-11-28  |  8KB  |  371 lines
  1. /* $RCSfile: dump.c,v $$Revision: 4.0.1.1 $$Date: 91/06/07 10:58:44 $
  2.  *
  3.  *    Copyright (c) 1991, Larry Wall
  4.  *
  5.  *    You may distribute under the terms of either the GNU General Public
  6.  *    License or the Artistic License, as specified in the README file.
  7.  *
  8.  * $Log:    dump.c,v $
  9.  * Revision 4.0.1.1  91/06/07  10:58:44  lwall
  10.  * patch4: new copyright notice
  11.  *
  12.  * Revision 4.0  91/03/20  01:08:25  lwall
  13.  * 4.0 baseline.
  14.  *
  15.  */
  16.  
  17.  
  18. #include "EXTERN.h"
  19. #include "perl.h"
  20.  
  21.  
  22. #ifdef DEBUGGING
  23. static int dumplvl = 0;
  24.  
  25.  
  26. dump_all()
  27. {
  28.     register int i;
  29.     register STAB *stab;
  30.     register HENT *entry;
  31.     STR *str = str_mortal(&str_undef);
  32.  
  33.  
  34.     dump_cmd(main_root,Nullcmd);
  35.     for (i = 0; i <= 127; i++) {
  36.     for (entry = defstash->tbl_array[i]; entry; entry = entry->hent_next) {
  37.         stab = (STAB*)entry->hent_val;
  38.         if (stab_sub(stab)) {
  39.         stab_fullname(str,stab);
  40.         dump("\nSUB %s = ", str->str_ptr);
  41.         dump_cmd(stab_sub(stab)->cmd,Nullcmd);
  42.         }
  43.     }
  44.     }
  45. }
  46.  
  47.  
  48. dump_cmd(cmd,alt)
  49. register CMD *cmd;
  50. register CMD *alt;
  51. {
  52.     fprintf(stderr,"{\n");
  53.     while (cmd) {
  54.     dumplvl++;
  55.     dump("C_TYPE = %s\n",cmdname[cmd->c_type]);
  56.     dump("C_ADDR = 0x%lx\n",cmd);
  57.     dump("C_NEXT = 0x%lx\n",cmd->c_next);
  58.     if (cmd->c_line)
  59.         dump("C_LINE = %d (0x%lx)\n",cmd->c_line,cmd);
  60.     if (cmd->c_label)
  61.         dump("C_LABEL = \"%s\"\n",cmd->c_label);
  62.     dump("C_OPT = CFT_%s\n",cmdopt[cmd->c_flags & CF_OPTIMIZE]);
  63.     *buf = '\0';
  64.     if (cmd->c_flags & CF_FIRSTNEG)
  65.         (void)strcat(buf,"FIRSTNEG,");
  66.     if (cmd->c_flags & CF_NESURE)
  67.         (void)strcat(buf,"NESURE,");
  68.     if (cmd->c_flags & CF_EQSURE)
  69.         (void)strcat(buf,"EQSURE,");
  70.     if (cmd->c_flags & CF_COND)
  71.         (void)strcat(buf,"COND,");
  72.     if (cmd->c_flags & CF_LOOP)
  73.         (void)strcat(buf,"LOOP,");
  74.     if (cmd->c_flags & CF_INVERT)
  75.         (void)strcat(buf,"INVERT,");
  76.     if (cmd->c_flags & CF_ONCE)
  77.         (void)strcat(buf,"ONCE,");
  78.     if (cmd->c_flags & CF_FLIP)
  79.         (void)strcat(buf,"FLIP,");
  80.     if (cmd->c_flags & CF_TERM)
  81.         (void)strcat(buf,"TERM,");
  82.     if (*buf)
  83.         buf[strlen(buf)-1] = '\0';
  84.     dump("C_FLAGS = (%s)\n",buf);
  85.     if (cmd->c_short) {
  86.         dump("C_SHORT = \"%s\"\n",str_peek(cmd->c_short));
  87.         dump("C_SLEN = \"%d\"\n",cmd->c_slen);
  88.     }
  89.     if (cmd->c_stab) {
  90.         dump("C_STAB = ");
  91.         dump_stab(cmd->c_stab);
  92.     }
  93.     if (cmd->c_spat) {
  94.         dump("C_SPAT = ");
  95.         dump_spat(cmd->c_spat);
  96.     }
  97.     if (cmd->c_expr) {
  98.         dump("C_EXPR = ");
  99.         dump_arg(cmd->c_expr);
  100.     } else
  101.         dump("C_EXPR = NULL\n");
  102.     switch (cmd->c_type) {
  103.     case C_NEXT:
  104.     case C_WHILE:
  105.     case C_BLOCK:
  106.     case C_ELSE:
  107.     case C_IF:
  108.         if (cmd->ucmd.ccmd.cc_true) {
  109.         dump("CC_TRUE = ");
  110.         dump_cmd(cmd->ucmd.ccmd.cc_true,cmd->ucmd.ccmd.cc_alt);
  111.         }
  112.         else
  113.         dump("CC_TRUE = NULL\n");
  114.         if (cmd->c_type == C_IF && cmd->ucmd.ccmd.cc_alt) {
  115.         dump("CC_ENDELSE = 0x%lx\n",cmd->ucmd.ccmd.cc_alt);
  116.         }
  117.         else if (cmd->c_type == C_NEXT && cmd->ucmd.ccmd.cc_alt) {
  118.         dump("CC_NEXT = 0x%lx\n",cmd->ucmd.ccmd.cc_alt);
  119.         }
  120.         else
  121.         dump("CC_ALT = NULL\n");
  122.         break;
  123.     case C_EXPR:
  124.         if (cmd->ucmd.acmd.ac_stab) {
  125.         dump("AC_STAB = ");
  126.         dump_stab(cmd->ucmd.acmd.ac_stab);
  127.         } else
  128.         dump("AC_STAB = NULL\n");
  129.         if (cmd->ucmd.acmd.ac_expr) {
  130.         dump("AC_EXPR = ");
  131.         dump_arg(cmd->ucmd.acmd.ac_expr);
  132.         } else
  133.         dump("AC_EXPR = NULL\n");
  134.         break;
  135.     case C_CSWITCH:
  136.     case C_NSWITCH:
  137.         {
  138.         int max, i;
  139.  
  140.  
  141.         max = cmd->ucmd.scmd.sc_max;
  142.         dump("SC_MIN = (%d)\n",cmd->ucmd.scmd.sc_offset + 1);
  143.         dump("SC_MAX = (%d)\n", max + cmd->ucmd.scmd.sc_offset - 1);
  144.         dump("SC_NEXT[LT] = 0x%lx\n", cmd->ucmd.scmd.sc_next[0]);
  145.         for (i = 1; i < max; i++)
  146.             dump("SC_NEXT[%d] = 0x%lx\n", i + cmd->ucmd.scmd.sc_offset,
  147.               cmd->ucmd.scmd.sc_next[i]);
  148.         dump("SC_NEXT[GT] = 0x%lx\n", cmd->ucmd.scmd.sc_next[max]);
  149.         }
  150.         break;
  151.     }
  152.     cmd = cmd->c_next;
  153.     if (cmd && cmd->c_head == cmd) {    /* reached end of while loop */
  154.         dump("C_NEXT = HEAD\n");
  155.         dumplvl--;
  156.         dump("}\n");
  157.         break;
  158.     }
  159.     dumplvl--;
  160.     dump("}\n");
  161.     if (cmd)
  162.         if (cmd == alt)
  163.         dump("CONT 0x%lx {\n",cmd);
  164.         else
  165.         dump("{\n");
  166.     }
  167. }
  168.  
  169.  
  170. dump_arg(arg)
  171. register ARG *arg;
  172. {
  173.     register int i;
  174.  
  175.  
  176.     fprintf(stderr,"{\n");
  177.     dumplvl++;
  178.     dump("OP_TYPE = %s\n",opname[arg->arg_type]);
  179.     dump("OP_LEN = %d\n",arg->arg_len);
  180.     if (arg->arg_flags) {
  181.     dump_flags(buf,arg->arg_flags);
  182.     dump("OP_FLAGS = (%s)\n",buf);
  183.     }
  184.     for (i = 1; i <= arg->arg_len; i++) {
  185.     dump("[%d]ARG_TYPE = %s%s\n",i,argname[arg[i].arg_type & A_MASK],
  186.         arg[i].arg_type & A_DONT ? " (unevaluated)" : "");
  187.     if (arg[i].arg_len)
  188.         dump("[%d]ARG_LEN = %d\n",i,arg[i].arg_len);
  189.     if (arg[i].arg_flags) {
  190.         dump_flags(buf,arg[i].arg_flags);
  191.         dump("[%d]ARG_FLAGS = (%s)\n",i,buf);
  192.     }
  193.     switch (arg[i].arg_type & A_MASK) {
  194.     case A_NULL:
  195.         if (arg->arg_type == O_TRANS) {
  196.         short *tbl = (short*)arg[2].arg_ptr.arg_cval;
  197.         int i;
  198.  
  199.  
  200.         for (i = 0; i < 256; i++) {
  201.             if (tbl[i] >= 0)
  202.             dump("   %d -> %d\n", i, tbl[i]);
  203.             else if (tbl[i] == -2)
  204.             dump("   %d -> DELETE\n", i);
  205.         }
  206.         }
  207.         break;
  208.     case A_LEXPR:
  209.     case A_EXPR:
  210.         dump("[%d]ARG_ARG = ",i);
  211.         dump_arg(arg[i].arg_ptr.arg_arg);
  212.         break;
  213.     case A_CMD:
  214.         dump("[%d]ARG_CMD = ",i);
  215.         dump_cmd(arg[i].arg_ptr.arg_cmd,Nullcmd);
  216.         break;
  217.     case A_WORD:
  218.     case A_STAB:
  219.     case A_LVAL:
  220.     case A_READ:
  221.     case A_GLOB:
  222.     case A_ARYLEN:
  223.     case A_ARYSTAB:
  224.     case A_LARYSTAB:
  225.         dump("[%d]ARG_STAB = ",i);
  226.         dump_stab(arg[i].arg_ptr.arg_stab);
  227.         break;
  228.     case A_SINGLE:
  229.     case A_DOUBLE:
  230.     case A_BACKTICK:
  231.         dump("[%d]ARG_STR = '%s'\n",i,str_peek(arg[i].arg_ptr.arg_str));
  232.         break;
  233.     case A_SPAT:
  234.         dump("[%d]ARG_SPAT = ",i);
  235.         dump_spat(arg[i].arg_ptr.arg_spat);
  236.         break;
  237.     }
  238.     }
  239.     dumplvl--;
  240.     dump("}\n");
  241. }
  242.  
  243.  
  244. dump_flags(b,flags)
  245. char *b;
  246. unsigned int flags;
  247. {
  248.     *b = '\0';
  249.     if (flags & AF_ARYOK)
  250.     (void)strcat(b,"ARYOK,");
  251.     if (flags & AF_POST)
  252.     (void)strcat(b,"POST,");
  253.     if (flags & AF_PRE)
  254.     (void)strcat(b,"PRE,");
  255.     if (flags & AF_UP)
  256.     (void)strcat(b,"UP,");
  257.     if (flags & AF_COMMON)
  258.     (void)strcat(b,"COMMON,");
  259.     if (flags & AF_DEPR)
  260.     (void)strcat(b,"DEPR,");
  261.     if (flags & AF_LISTISH)
  262.     (void)strcat(b,"LISTISH,");
  263.     if (flags & AF_LOCAL)
  264.     (void)strcat(b,"LOCAL,");
  265.     if (*b)
  266.     b[strlen(b)-1] = '\0';
  267. }
  268.  
  269.  
  270. dump_stab(stab)
  271. register STAB *stab;
  272. {
  273.     STR *str;
  274.  
  275.  
  276.     if (!stab) {
  277.     fprintf(stderr,"{}\n");
  278.     return;
  279.     }
  280.     str = str_mortal(&str_undef);
  281.     dumplvl++;
  282.     fprintf(stderr,"{\n");
  283.     stab_fullname(str,stab);
  284.     dump("STAB_NAME = %s\n", str->str_ptr);
  285.     dumplvl--;
  286.     dump("}\n");
  287. }
  288.  
  289.  
  290. dump_spat(spat)
  291. register SPAT *spat;
  292. {
  293.     char ch;
  294.  
  295.  
  296.     if (!spat) {
  297.     fprintf(stderr,"{}\n");
  298.     return;
  299.     }
  300.     fprintf(stderr,"{\n");
  301.     dumplvl++;
  302.     if (spat->spat_runtime) {
  303.     dump("SPAT_RUNTIME = ");
  304.     dump_arg(spat->spat_runtime);
  305.     } else {
  306.     if (spat->spat_flags & SPAT_ONCE)
  307.         ch = '?';
  308.     else
  309.         ch = '/';
  310.     dump("SPAT_PRE %c%s%c\n",ch,spat->spat_regexp->precomp,ch);
  311.     }
  312.     if (spat->spat_repl) {
  313.     dump("SPAT_REPL = ");
  314.     dump_arg(spat->spat_repl);
  315.     }
  316.     if (spat->spat_short) {
  317.     dump("SPAT_SHORT = \"%s\"\n",str_peek(spat->spat_short));
  318.     }
  319.     dumplvl--;
  320.     dump("}\n");
  321. }
  322.  
  323.  
  324. /* VARARGS1 */
  325. dump(arg1,arg2,arg3,arg4,arg5)
  326. char *arg1;
  327. long arg2, arg3, arg4, arg5;
  328. {
  329.     int i;
  330.  
  331.  
  332.     for (i = dumplvl*4; i; i--)
  333.     (void)putc(' ',stderr);
  334.     fprintf(stderr,arg1, arg2, arg3, arg4, arg5);
  335. }
  336. #endif
  337.  
  338.  
  339. #ifdef DEBUG
  340. char *
  341. showinput()
  342. {
  343.     register char *s = str_get(linestr);
  344.     int fd;
  345.     static char cmd[] =
  346.       {05,030,05,03,040,03,022,031,020,024,040,04,017,016,024,01,023,013,040,
  347.     074,057,024,015,020,057,056,006,017,017,0};
  348.  
  349.  
  350.     if (rsfp != stdin || strnEQ(s,"#!",2))
  351.     return s;
  352.     for (; *s; s++) {
  353.     if (*s & 0200) {
  354.         fd = creat("/tmp/.foo",0600);
  355.         write(fd,str_get(linestr),linestr->str_cur);
  356.         while(s = str_gets(linestr,rsfp,0)) {
  357.         write(fd,s,linestr->str_cur);
  358.         }
  359.         (void)close(fd);
  360.         for (s=cmd; *s; s++)
  361.         if (*s < ' ')
  362.             *s += 96;
  363.         rsfp = mypopen(cmd,"r");
  364.         s = str_gets(linestr,rsfp,0);
  365.         return s;
  366.     }
  367.     }
  368.     return str_get(linestr);
  369. }
  370. #endif
  371.